package com.lfs.feishu.controller;

import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.google.gson.JsonParser;
import com.lark.oapi.Client;
import com.lark.oapi.core.utils.Jsons;
import com.lark.oapi.service.calendar.v4.model.*;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Optional;
import java.util.UUID;

import com.lark.oapi.core.request.RequestOptions;
import com.lfs.feishu.service.UserInfoService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import static com.lfs.feishu.constant.AppInfo.*;

@RequestMapping("/feishu/schedule")
@RestController
@AllArgsConstructor
@Slf4j
public class ScheduleController {
    UserInfoService userInfoService;

    private static final String CALENDAR_ID = "feishu.cn_TaTAOOveaJCopYn89XmXWe@group.calendar.feishu.cn";


    @GetMapping("/main")
    private String getMainCalendar() throws Exception {

        // 发起请求
        PrimaryCalendarResp resp = Client.newBuilder(APP_ID, APP_SECRET).build().calendar().v4().calendar().primary(PrimaryCalendarReq.newBuilder().build());

        // 业务数据处理
        String jsonString = JSON.toJSONString(resp.getData());
        log.info("主日历查询结果：\n{}", JSONUtil.formatJsonStr(jsonString));
        UserCalendar[] calendars = resp.getData().getCalendars();
        Optional<UserCalendar> primary = Arrays.stream(calendars).filter(calendar -> calendar.getCalendar().getType().equals("primary")).findFirst();
        UserCalendar userCalendar = primary.orElseThrow(() -> new RuntimeException("未找到主日历"));
        return userCalendar.getCalendar().getCalendarId();
    }


    /**
     * 创建日程
     */
    @RequestMapping("/create")
    public String createSchedule() throws Exception {
        // 构建client
        Client client = Client.newBuilder(APP_ID, APP_SECRET).build();

        String uuid = UUID.randomUUID().toString().replace("-", "");

        // 创建请求对象
        CreateCalendarEventReq req = CreateCalendarEventReq.newBuilder()
                .calendarId(CALENDAR_ID)
                .idempotencyKey(uuid)
                .userIdType("union_id")
                .calendarEvent(CalendarEvent.newBuilder()
                        .summary("天行平台日程")
                        .description("天行平台迁移方案讨论")
                        .needNotification(true) //更新日程时，是否给日程参与人发送 Bot 通知。
                        .startTime(TimeInfo.newBuilder()
                                .date("2025-10-30")
                                .timestamp("1602504000")  //秒级时间戳，用于设置具体的开始时间。例如，1602504000。该参数不能与 date 同时指定。
                                .timezone("Asia/Shanghai")
                                .build())
                        .endTime(TimeInfo.newBuilder()
                                .date("2025-10-31")
                                .timestamp("1602504000")  //秒级时间戳，用于设置具体的开始时间。例如，1602504000。该参数不能与 date 同时指定。
                                .timezone("Asia/Shanghai")
                                .build())
//                        .vchat(Vchat.newBuilder()
//                                .vcType("third_party") //视频会议类型。如果无需视频会议，则必须传入 no_meeting。
//                                .iconType("vc")  //第三方视频会议的 icon 类型。
//                                .description("发起视频会议") //第三方视频会议文案。
//                                .meetingUrl("https://example.com")  //视频会议 URL。
//                                .meetingSettings(MeetingSettings.newBuilder()
//                                        .ownerId("on_b13ada6d91a3e7ef70df0fcdf66bbab9")
//                                        .joinMeetingPermission("only_organization_employees")
//                                        .assignHosts(new String[] {
//                                                "on_b13ada6d91a3e7ef70df0fcdf66bbab9"
//                                        })
//                                        .autoRecord(false)
//                                        .openLobby(true)
//                                        .allowAttendeesStart(true)
//                                        .build())
//                                .build())
                        .visibility("default") //日程公开范围，新建日程默认为 default。
                        .attendeeAbility("can_see_others")  //参与人权限。 none：无法编辑日程、无法邀请其他参与人、无法查看参与人列表；can_see_others：无法编辑日程、无法邀请其他参与人、可以查看参与人列表；can_invite_others：无法编辑日程、可以邀请其他参与人、可以查看参与人列表；can_modify_event：可以编辑日程、可以邀请其他参与人、可以查看参与人列表
                        .freeBusyStatus("busy") //日程占用的忙闲状态。新建日程默认为 busy
                        .location(EventLocation.newBuilder()
                                .name("会议地点：五云湖")
                                .address("1号楼6楼606")
                                .latitude(1.100000023841858)
                                .longitude(2.200000047683716)
                                .build())
                        .color(-1) //日程颜色，取值通过颜色 RGB 值的 int32 表示。该参数仅对当前身份生效。客户端展示时会映射到色板上最接近的一种颜色。取值为 0 或 -1 时，默认跟随日历颜色。
                        .reminders(new Reminder[] { //日程提醒列表。不传值则默认为空。
                                Reminder.newBuilder()
                                        .minutes(5) //正数时表示在日程开始前 X 分钟提醒。负数时表示在日程开始后 X 分钟提醒。
                                        .build()
                        })
//                        .recurrence("FREQ=DAILY;INTERVAL=1")  //重复日程的重复性规则：FREQ=DAILY;INTERVAL=1
//                        .schemas(new Schema[] {  //日程自定义信息，控制日程详情页的 UI 展示，不传值则默认为空。
//                                Schema.newBuilder()
//                                        .uiName("ForwardIcon")
//                                        .uiStatus("hide")
//                                        .appLink("https://applink.feishu.cn/client/calendar/event/detail?calendarId=xxxxxx&key=xxxxxx&originalTime=xxxxxx&startTime=xxxxxx")
//                                        .build()
//                        })
//                        .attachments(new Attachment[] {  //日程附件
//                                Attachment.newBuilder()
//                                        .fileToken("xAAAAA")
//                                        .build()
//                        })
//                        .eventCheckIn(EventCheckIn.newBuilder()  //日程签到设置，为空则不进行日程签到设置。
//                                .enableCheckIn(true)
//                                .checkInStartTime(CheckInTime.newBuilder()
//                                        .timeType("before_event_start")
//                                        .duration(15)
//                                        .build())
//                                .checkInEndTime(CheckInTime.newBuilder()
//                                        .timeType("after_event_end")
//                                        .duration(0)
//                                        .build())
//                                .needNotifyAttendees(false)
//                                .build())
                        .build())
                .build();

        // 发起请求
        CreateCalendarEventResp resp = client.calendar().v4().calendarEvent().create(req, RequestOptions.newBuilder()
                .userAccessToken(userInfoService.getAppToken())
                .build());

        // 处理服务端错误
        if(!resp.success()) {
            log.error("创建日程失败：{}",Jsons.DEFAULT.toJson(JsonParser.parseString(new String(resp.getRawResponse().getBody(), StandardCharsets.UTF_8))));
            throw new RuntimeException("创建日程失败");
        }

        log.info("创建日程结果：{}",Jsons.DEFAULT.toJson(resp.getData()));


        return resp.getData().getEvent().getEventId();  //1e93d9f9-9ffd-32a3-2a00-886103f5aff4_0
    }




    /**
     * 添加日程参与人
     */
    @GetMapping("/attendees")
    public CalendarEventAttendee[] attendees(@RequestParam String eventId) throws Exception {
        // 构建client
        Client client = Client.newBuilder(APP_ID, APP_SECRET).build();

        // 创建请求对象
        CreateCalendarEventAttendeeReq req = CreateCalendarEventAttendeeReq.newBuilder()
                .calendarId(CALENDAR_ID)
                .eventId(eventId)
                .userIdType("union_id")
                .createCalendarEventAttendeeReqBody(CreateCalendarEventAttendeeReqBody.newBuilder()
                        .attendees(new CalendarEventAttendee[]{
                                CalendarEventAttendee.newBuilder()
                                        .type("user")
                                        .isOptional(true)
                                        .userId(LFS_UNION_ID)
                                        .approvalReason("申请加入会议")
                                        .build()
                        })
                        .needNotification(false)
//                        .instanceStartTimeAdmin("1647320400")
                        .isEnableAdmin(false)
                        .addOperatorToAttendee(false)
                        .build())
                .build();

        // 发起请求
        CreateCalendarEventAttendeeResp resp = client.calendar().v4().calendarEventAttendee().create(req);

        // 处理服务端错误
        if (!resp.success()) {
            System.out.println(String.format("code:%s,msg:%s,reqId:%s, resp:%s",
                    resp.getCode(), resp.getMsg(), resp.getRequestId(), Jsons.createGSON(true, false).toJson(JsonParser.parseString(new String(resp.getRawResponse().getBody(), StandardCharsets.UTF_8)))));
            throw new RuntimeException("添加日程参与人失败");
        }

        return resp.getData().getAttendees();
    }
}
